package com.niit.scala

import scala.collection.immutable.Map

/**
 * Date:2025/3/26
 * Author：Ys
 * Description:
 */
object Base08 {

  def main(args: Array[String]): Unit = {
    /*
        集：  唯一且无序(添加的顺序和取出的顺序不一致)
         1.不可变集
         2.可变集
         3.集的操作
     */
    //1.不可变集
    var set1 =Set[Int]() // 不可变的空集 数据类型是整型
    var set2 = Set(2,1,4,1,2,4,9,8)
    println(set2)

    //2.可变集 手动的引入包
    import scala.collection.mutable.Set
    var set3 = Set(1,2,3,4,1,2,3,5,1,6)
    set1 += 10
    set3 += 20
    set3 --= Set(1,2,3)
    println(set1,set3)

    /*
      映射  -->  字典  --> Map  --->  键值对
      1.不可变映射
      2.可变映射
      3.Map操作
     */
    //1.不可变映射
    var map1 = Map( "张三" -> 23 ,"李四" -> 24,  "王五" -> 25    )
    var map2 = Map(  ("张三",23), ("李四",24)  ,   ("王五",25)         )//常用

    println(map1,map2)
    //2.可变映射 手动的引入包
    import scala.collection.mutable.Map
    var map3 = Map(  ("张三",23), ("李四",24)  ,   ("王五",25)         )

    //3.映射的操作
    //根据键获取值
    //println(map3("李三"))
    println(map3.get("李三")) //如果该键不存在，不会报错而是返回None
    //根据Key修改value
    map3("张三") = 30
    println(map3)
    map3("赵四") = 78 //如果该键不存在，会自动添加该键值对，如果该键存在，会修改该键对应的value
    println(map3)

    //获得所有键 和 所有值
    println( map3.keys )
    println( map3.values )
    //映射的遍历
    for( (k,v) <- map3 ){
      println(k,v)
    }

    /*
      迭代器：Scala针对每一类的集合都提供了一个迭代器，用来集合遍历访问。
             迭代器通过和while循环配合使用
                hasNext:查询迭代器中是否有下一个元素
                next:获取迭代器中的下一个元素
     */
    var list = List(1,2,3,4,5,6,7,8,9)
    val iterator: Iterator[Int] = list.iterator
    while (iterator.hasNext){
      println(iterator.next())
    }

    /*
    函数式编程：方法的参数列表 可以接收 函数对象
     */
    //1. foreach  用于遍历，打印数据  不会返回一个新列表
    var list1 = List(1,2,3,4,5,6,7,8,9)
    // 初级版  x：表示列表中的每一个元素
    list1.foreach(   (x:Int) => println( x  )          )
    // 升级版 ：利用类型推断的特性
    list1.foreach(   x  => println( x  ))
    //究极版  _: 表示列表中的每一个元素
    list1.foreach( println( _ ) )

    //2.map: 用于对列表中的每一个元素进行操作，并返回一个新列表
    //需求：某电影网站 需要观众对电进行打分，等级 1 2 3 4 ，但是观众对电影打分是 *
    var list2 = List(1,2,3,4)  // ==> List("*","**","***","****")
    //初级版
    val ll1: List[String] = list2.map( (i: Int) => "*" * i)
    //升级版
    val ll2: List[String] = list2.map(i => "*" * i)
    //究极版
    val ll3: List[String] = list2.map("*" * _)
    println(ll3)

    //3.flatMap:  将一个列表中的每一个元素，进行操作，并返回一个新列表，并且将新列表中的每一个元素，进行扁平化
    //  Map  +  flatten
    var list3 = List("hadoop hive spark flume", "hbase java python java")
    //==> List("hadoop","hive","spark","flume","hbase","java","python","java")

    /*
       思路：对每一个元素先以为空格 进行切割，并对切割后的元素返回到新的列表当中
            切割后的元素我们再进行扁平化
     */
    val ll4: List[Array[String]] = list3.map(_.split(" "))
    //==> List( Array("hadoop","hive","spark","flume"), Array("hbase","java","python","java") )
    val ll5: List[String] = ll4.flatten
    println(ll5)

    val ll6: List[String] = list3.flatMap(_.split(" "))
    println(ll6)
  }

}
